﻿using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using 温湿度和颗粒度监控测试.Common;
using 温湿度和颗粒度监控测试.Common.传感器;

namespace 温湿度和颗粒度监控测试.ViewModel
{
    public class 综合显示WindowViewModel : NotifyBase
    {
        public delegate void MessageHandler(string msg);
        public MessageHandler ErrorMessageEvent;
        public MessageHandler InfoMessageEvent;

        public delegate bool ConfirmMessageHandler(string msg);
        public ConfirmMessageHandler ConfirmMessageEvent;


        private double _点1温度;

        public double 点1温度 { get => _点1温度; set => SetProperty(ref _点1温度, value); }

        private double _点1湿度;

        public double 点1湿度 { get => _点1湿度; set => SetProperty(ref _点1湿度, value); }

        private double _点2温度;

        public double 点2温度 { get => _点2温度; set => SetProperty(ref _点2温度, value); }

        private double _点2湿度;

        public double 点2湿度 { get => _点2湿度; set => SetProperty(ref _点2湿度, value); }

        private int _AM1050颗粒度;

        public int AM1050颗粒度 { get => _AM1050颗粒度; set => SetProperty(ref _AM1050颗粒度, value); }

        private int _OPC6303M颗粒度;

        public int OPC6303M颗粒度 { get => _OPC6303M颗粒度; set => SetProperty(ref _OPC6303M颗粒度, value); }

        private int _攀藤颗粒度;

        public int 攀藤颗粒度 { get => _攀藤颗粒度; set => SetProperty(ref _攀藤颗粒度, value); }


        温湿度记颗粒度传感器 温湿度记颗粒度传感器Client;

        bool isClientConnected = false;

        bool 是否监控 = false;

        public void 开始监控()
        {
            try
            {
                if (温湿度记颗粒度传感器Client == null) 温湿度记颗粒度传感器Client = new 温湿度记颗粒度传感器();

                if (isClientConnected)
                {
                    // 断开串口
                    isClientConnected = false;
                    温湿度记颗粒度传感器Client.Close();
                }
                else
                {
                    // 打开串口
                    温湿度记颗粒度传感器Client.PortName = "COM4";
                    isClientConnected = true;

                    // 监控显示UI
                    _ = Task.Run(() =>
                    {
                        while (isClientConnected)
                        {
                            try
                            {
                                #region 读取数据
                                // 读取温度
                                double l_点1温度 = 温湿度记颗粒度传感器Client.获取温度值(0x01, 200);
                                double l_点2温度 = 温湿度记颗粒度传感器Client.获取温度值(0x02, 200);

                                // 读取湿度
                                double l_点1湿度 = 温湿度记颗粒度传感器Client.获取湿度值(0x01, 200);
                                double l_点2湿度 = 温湿度记颗粒度传感器Client.获取湿度值(0x02, 200);

                                // 读取AM1050的颗粒度
                                int l_AM1050的颗粒度 = 温湿度记颗粒度传感器Client.获取AM1050的PM05颗粒度(0x32, 300);

                                // 读取OPC-6303C的颗粒度
                                int l_OPC6303C的颗粒度 = 温湿度记颗粒度传感器Client.获取OPC6030M的PM05(0x31, 300);

                                // 读取攀藤的颗粒度
                                int l_攀藤的颗粒度 = 温湿度记颗粒度传感器Client.获取攀藤的PM05(0x33, 300);
                                #endregion

                                // 设置显示UI
                                点1温度 = l_点1温度 == -1000 ? 点1温度 : l_点1温度;
                                点2温度 = l_点2温度 == -1000 ? 点2温度 : l_点2温度;
                                点1湿度 = l_点1湿度 == -1000 ? 点1湿度 : l_点1湿度;
                                点2湿度 = l_点2湿度 == -1000 ? 点2湿度 : l_点2湿度;
                                AM1050颗粒度 = l_AM1050的颗粒度 == -1000 ? AM1050颗粒度 : l_AM1050的颗粒度;
                                OPC6303M颗粒度 = l_OPC6303C的颗粒度 == -1000 ? OPC6303M颗粒度 : l_OPC6303C的颗粒度;
                                攀藤颗粒度 = l_攀藤的颗粒度 == -1000 ? 攀藤颗粒度 : l_攀藤的颗粒度;

                                Thread.Sleep(100);    // 间隔10分钟记录一次
                            }
                            catch (Exception ex)
                            {
                                LogHelper.Error(ex);
                                if (ConfirmMessageEvent?.Invoke($"{ex.Message}\r\n是否停止监控？") == true)
                                {
                                    停止监控();
                                    停止监控Event?.Invoke();
                                    break;
                                }
                            }
                        }
                    });

                    // 记录log线程
                    _ = Task.Run(() =>
                    {
                        while (isClientConnected)
                        {
                            try
                            {
                                // 记录本地Log
                                string logFile = $"{Environment.CurrentDirectory}\\监控日志";
                                if (!Directory.Exists(logFile)) Directory.CreateDirectory(logFile);
                                logFile += $"\\{DateTime.Now:yyyy-MM-dd}.csv";
                                string content = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss},{点1温度},{点2温度},{点1湿度},{点2湿度},{AM1050颗粒度},{OPC6303M颗粒度},{攀藤颗粒度}\r\n";
                                if (!File.Exists(logFile)) content = "时间,点1温度,点2温度,点1湿度,点2湿度,AM1050颗粒度,OPC-6303C颗粒度,攀藤颗粒度\r\n" + content;
                                FileHelper.Write(logFile, content, FileMode.Append);

                                Thread.Sleep(10 * 60 * 1000);    // 间隔10分钟记录一次
                            }
                            catch (Exception ex)
                            {
                                LogHelper.Error(ex);
                                if (ConfirmMessageEvent?.Invoke($"{ex.Message}\r\n是否停止监控？") == true)
                                {
                                    停止监控();
                                    停止监控Event?.Invoke();
                                    break;
                                }
                            }
                        }
                    });
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex);
                ErrorMessageEvent?.Invoke(ex.Message);
            }
        }

        public delegate void 停止监控Handler();
        public 停止监控Handler 停止监控Event;

        public void 停止监控()
        {
            try
            {
                温湿度记颗粒度传感器Client.Close();
                isClientConnected = false;
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex);
                ErrorMessageEvent?.Invoke(ex.Message);
            }
        }
    }
}
